GCC Code Coverage Report
Directory: ./ Exec Total Coverage
File: test/zserio/ReflectableTest.cpp Lines: 970 970 100.0 %
Date: 2023-05-11 12:53:48 Branches: 10523 55427 19.0 %

Line Branch Exec Source
1
#include <string>
2
#include <functional>
3
#include <type_traits>
4
5
#include "gtest/gtest.h"
6
7
#include "zserio/ArrayTraits.h"
8
#include "zserio/BitStreamReader.h"
9
#include "zserio/BitStreamWriter.h"
10
#include "zserio/BitSizeOfCalculator.h"
11
#include "zserio/Reflectable.h"
12
#include "zserio/Vector.h"
13
14
#include "test_object/std_allocator/ReflectableBitmask.h"
15
#include "test_object/std_allocator/ReflectableEnum.h"
16
#include "test_object/std_allocator/ReflectableNested.h"
17
#include "test_object/std_allocator/ReflectableObject.h"
18
19
using test_object::std_allocator::ReflectableBitmask;
20
using test_object::std_allocator::ReflectableEnum;
21
using test_object::std_allocator::ReflectableNested;
22
using test_object::std_allocator::ReflectableObject;
23
24
using namespace std::placeholders;
25
26
namespace zserio
27
{
28
29
namespace
30
{
31
32
5
ReflectableObject createInitializedReflectableObject(const string<>& stringField,
33
        uint32_t reflectableNestedValue)
34
{
35
5
    ReflectableObject reflectableObject(stringField, ReflectableNested{reflectableNestedValue});
36
5
    reflectableObject.initializeChildren();
37
5
    return reflectableObject;
38
}
39
40
} // namespace
41
42
122
class ReflectableTest : public ::testing::Test
43
{
44
protected:
45
    template <typename RAW_ARRAY, typename REFLECTABLE_PTR, typename ELEMENT_CHECKER>
46
22
    void checkArray(const RAW_ARRAY& rawArray, const REFLECTABLE_PTR& reflectable,
47
            const ELEMENT_CHECKER& elementChecker)
48
    {
49













































































22
        ASSERT_TRUE(reflectable->isArray());
50













































































22
        ASSERT_EQ(rawArray.size(), reflectable->size());
51











90
        for (size_t i = 0; i < rawArray.size(); ++i)
52
        {
53











68
            if (i % 2 == 0)
54






















40
                elementChecker(rawArray[i], reflectable->at(i));
55
            else
56






































28
                elementChecker(rawArray[i], (*reflectable)[i]);
57
        }
58
59






















































































































































































































44
        ASSERT_THROW(reflectable->at(rawArray.size()), CppRuntimeException);
60






































































































































































































44
        ASSERT_THROW((*reflectable)[rawArray.size()], CppRuntimeException);
61
62
        using ReflectableType = typename REFLECTABLE_PTR::element_type;
63
        if (std::is_const<ReflectableType>::value)
64
        {
65


































































14
            ASSERT_EQ(rawArray,
66
                    reflectable->getAnyValue().template get<std::reference_wrapper<const RAW_ARRAY>>().get());
67
        }
68
        else
69
        {
70






































8
            ASSERT_EQ(rawArray,
71
                    reflectable->getAnyValue().template get<std::reference_wrapper<RAW_ARRAY>>().get());
72
        }
73
74






















































































































































































































44
        ASSERT_THROW(reflectable->getBool(), CppRuntimeException);
75






















































































































































































































44
        ASSERT_THROW(reflectable->getInt8(), CppRuntimeException);
76






















































































































































































































44
        ASSERT_THROW(reflectable->getInt16(), CppRuntimeException);
77






















































































































































































































44
        ASSERT_THROW(reflectable->getInt32(), CppRuntimeException);
78






















































































































































































































44
        ASSERT_THROW(reflectable->getInt64(), CppRuntimeException);
79






















































































































































































































44
        ASSERT_THROW(reflectable->getUInt8(), CppRuntimeException);
80






















































































































































































































44
        ASSERT_THROW(reflectable->getUInt16(), CppRuntimeException);
81






















































































































































































































44
        ASSERT_THROW(reflectable->getUInt32(), CppRuntimeException);
82






















































































































































































































44
        ASSERT_THROW(reflectable->getUInt64(), CppRuntimeException);
83






















































































































































































































44
        ASSERT_THROW(reflectable->getFloat(), CppRuntimeException);
84






















































































































































































































44
        ASSERT_THROW(reflectable->getDouble(), CppRuntimeException);
85






















































































































































































































44
        ASSERT_THROW(reflectable->getBytes(), CppRuntimeException);
86






















































































































































































































44
        ASSERT_THROW(reflectable->getStringView(), CppRuntimeException);
87






















































































































































































































44
        ASSERT_THROW(reflectable->getBitBuffer(), CppRuntimeException);
88
89






















































































































































































































44
        ASSERT_THROW(reflectable->toInt(), CppRuntimeException);
90






















































































































































































































44
        ASSERT_THROW(reflectable->toUInt(), CppRuntimeException);
91






















































































































































































































44
        ASSERT_THROW(reflectable->toDouble(), CppRuntimeException);
92






















































































































































































































44
        ASSERT_THROW(reflectable->toString(), CppRuntimeException);
93
94






































































































































































































44
        ASSERT_THROW(reflectable->bitSizeOf(0), CppRuntimeException);
95
96



























44
        BitBuffer bitBuffer(0);
97











22
        BitStreamWriter writer(bitBuffer);
98






































































































































































































44
        ASSERT_THROW(reflectable->write(writer), CppRuntimeException);
99
100






















22
        checkNonCompound(reflectable);
101
    }
102
103
    template <typename T, typename REFLECTABLE_PTR, typename READ_FUNC>
104
117
    void checkWriteRead(T value, const REFLECTABLE_PTR& reflectable, const READ_FUNC& readFunc,
105
            size_t bitBufferSize)
106
    {
107



















234
        BitBuffer bitBuffer(bitBufferSize);
108



















117
        BitStreamWriter writer(bitBuffer);
109



















117
        reflectable->write(writer);
110



















117
        const size_t bitSizeOfValue = reflectable->bitSizeOf();
111





















































































































117
        ASSERT_EQ(bitSizeOfValue, writer.getBitPosition());
112
113



















117
        BitStreamReader reader(bitBuffer);
114








































































































































117
        ASSERT_EQ(value, readFunc(reader));
115








































































































































117
        ASSERT_EQ(bitSizeOfValue, reader.getBitPosition());
116
    }
117
118
117
    void checkNonArray(const IReflectableConstPtr& reflectable)
119
    {
120




117
        ASSERT_FALSE(reflectable->isArray());
121










234
        ASSERT_THROW(reflectable->size(), CppRuntimeException);
122










234
        ASSERT_THROW(reflectable->at(0), CppRuntimeException);
123









234
        ASSERT_THROW((*reflectable)[0], CppRuntimeException);
124
    }
125
126
69
    void checkNonArray(const IReflectablePtr& reflectable)
127
    {
128

69
        checkNonArray(static_cast<IReflectableConstPtr>(reflectable));
129
130










138
        ASSERT_THROW(reflectable->at(0), CppRuntimeException);
131










138
        ASSERT_THROW((*reflectable)[0], CppRuntimeException);
132









138
        ASSERT_THROW(reflectable->resize(1), CppRuntimeException);
133










138
        ASSERT_THROW(reflectable->setAt(AnyHolder<>(), 0), CppRuntimeException);
134
    }
135
136
    template <typename REFLECTABLE_PTR>
137
128
    void checkNonCompoundConstMethods(const REFLECTABLE_PTR& reflectable)
138
    {
139




















256
        ASSERT_THROW(reflectable->getField("field"), CppRuntimeException);
140




















256
        ASSERT_THROW(reflectable->getParameter("parameter"), CppRuntimeException);
141






















256
        ASSERT_THROW(reflectable->callFunction("function"), CppRuntimeException);
142



















256
        ASSERT_THROW(reflectable->getChoice(), CppRuntimeException);
143
144







128
        ASSERT_EQ(nullptr, reflectable->find("some.field"));
145







128
        ASSERT_EQ(nullptr, (*reflectable)["some.field"]);
146
    }
147
148
74
    void checkNonCompound(const IReflectablePtr& reflectable)
149
    {
150









148
        ASSERT_THROW(reflectable->initializeChildren(), CppRuntimeException);
151










148
        ASSERT_THROW(reflectable->initialize(vector<AnyHolder<>>()), CppRuntimeException);
152










148
        ASSERT_THROW(reflectable->setField("field", AnyHolder<>{}), CppRuntimeException);
153











148
        ASSERT_THROW(reflectable->createField("field"), CppRuntimeException);
154









148
        ASSERT_THROW(reflectable->initializeOffsets(), CppRuntimeException);
155
156
74
        checkNonCompoundConstMethods(reflectable);
157
    }
158
159
54
    void checkNonCompound(const IReflectableConstPtr& reflectable)
160
    {
161
54
        checkNonCompoundConstMethods(reflectable);
162
54
    }
163
164
    template <typename T, typename REFLECTABLE_PTR, typename GETTER>
165
280
    void checkArithmeticCppTypeGetter(T value, const REFLECTABLE_PTR& reflectable,
166
            CppType cppType, const GETTER& getter, bool& match)
167
    {
168







































































280
        if (reflectable->getTypeInfo().getCppType() == cppType)
169
        {
170







































































































































































































































































































































































































































































































































































































































































































64
            ASSERT_EQ(value, ((*reflectable).*getter)());
171
64
            match = true;
172
        }
173
        else
174
        {
175














































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































432
            ASSERT_THROW(((*reflectable).*getter)(), CppRuntimeException);
176
        }
177
    }
178
179
    template <typename T, typename REFLECTABLE_PTR>
180
64
    void checkArithmeticCppTypeGetters(T value, const REFLECTABLE_PTR& reflectable)
181
    {
182






64
        const ITypeInfo& typeInfo = reflectable->getTypeInfo();
183
64
        bool match = false;
184



















64
        if (TypeInfoUtil::isFloatingPoint(typeInfo.getCppType()))
185
        {
186






3
            checkArithmeticCppTypeGetter(value, reflectable,
187
                    CppType::FLOAT, &IReflectable::getFloat, match);
188






3
            checkArithmeticCppTypeGetter(value, reflectable,
189
                    CppType::DOUBLE, &IReflectable::getDouble, match);
190
        }
191



















61
        else if (TypeInfoUtil::isSigned(typeInfo.getCppType()))
192
        {
193













































31
            ASSERT_EQ(static_cast<int64_t>(value), reflectable->toInt());
194
195






31
            checkArithmeticCppTypeGetter(value, reflectable,
196
                    CppType::INT8, &IReflectable::getInt8, match);
197






31
            checkArithmeticCppTypeGetter(value, reflectable,
198
                    CppType::INT16, &IReflectable::getInt16, match);
199






31
            checkArithmeticCppTypeGetter(value, reflectable,
200
                    CppType::INT32, &IReflectable::getInt32, match);
201






31
            checkArithmeticCppTypeGetter(value, reflectable,
202
                    CppType::INT64, &IReflectable::getInt64, match);
203
        }
204
        else
205
        {
206













































30
            ASSERT_EQ(static_cast<uint64_t>(value), reflectable->toUInt());
207
208






30
            checkArithmeticCppTypeGetter(value, reflectable,
209
                    CppType::BOOL, &IReflectable::getBool, match);
210






30
            checkArithmeticCppTypeGetter(value, reflectable,
211
                    CppType::UINT8, &IReflectable::getUInt8, match);
212






30
            checkArithmeticCppTypeGetter(value, reflectable,
213
                    CppType::UINT16, &IReflectable::getUInt16, match);
214






30
            checkArithmeticCppTypeGetter(value, reflectable,
215
                    CppType::UINT32, &IReflectable::getUInt32, match);
216






30
            checkArithmeticCppTypeGetter(value, reflectable,
217
                    CppType::UINT64, &IReflectable::getUInt64, match);
218
        }
219
220







































64
        ASSERT_TRUE(match);
221
    }
222
223
    template <typename T, typename REFLECTABLE_PTR, typename GETTER, typename READ_FUNC>
224
3
    void checkFloatingPoint(T value, const REFLECTABLE_PTR& reflectable,
225
            const GETTER& getter, const READ_FUNC& readFunc, size_t bitSize = sizeof(T) * 8)
226
    {
227








3
        ASSERT_EQ(value, ((*reflectable).*getter)());
228
229








3
        ASSERT_EQ(value, reflectable->toDouble());
230



















6
        ASSERT_THROW(reflectable->toInt(), CppRuntimeException);
231



















6
        ASSERT_THROW(reflectable->toUInt(), CppRuntimeException);
232



















6
        ASSERT_THROW(reflectable->toString(), CppRuntimeException); // NOT IMPLEMENTED!
233
234



















6
        ASSERT_THROW(reflectable->getInt8(), CppRuntimeException);
235



















6
        ASSERT_THROW(reflectable->getInt16(), CppRuntimeException);
236



















6
        ASSERT_THROW(reflectable->getInt32(), CppRuntimeException);
237



















6
        ASSERT_THROW(reflectable->getInt64(), CppRuntimeException);
238



















6
        ASSERT_THROW(reflectable->getUInt8(), CppRuntimeException);
239



















6
        ASSERT_THROW(reflectable->getUInt16(), CppRuntimeException);
240



















6
        ASSERT_THROW(reflectable->getUInt32(), CppRuntimeException);
241



















6
        ASSERT_THROW(reflectable->getUInt64(), CppRuntimeException);
242



















6
        ASSERT_THROW(reflectable->getBytes(), CppRuntimeException);
243



















6
        ASSERT_THROW(reflectable->getStringView(), CppRuntimeException);
244


















6
        ASSERT_THROW(reflectable->getBitBuffer(), CppRuntimeException);
245
246
3
        checkArithmeticCppTypeGetters(value, reflectable);
247
248
3
        checkNonCompound(reflectable);
249
3
        checkNonArray(reflectable);
250
251
3
        checkWriteRead(value, reflectable, readFunc, bitSize);
252
    }
253
254
    template <typename T, typename REFLECTABLE_PTR, typename GETTER, typename READ_FUNC>
255
61
    void checkIntegral(T value, const REFLECTABLE_PTR& reflectable,
256
            const GETTER& getter, const READ_FUNC& readFunc, size_t bitSize)
257
    {
258




































































































61
        ASSERT_EQ(value, ((*reflectable).*getter)());
259
260




































































































61
        ASSERT_EQ(value, reflectable->getAnyValue().template get<T>());
261
262























































































61
        ASSERT_DOUBLE_EQ(static_cast<double>(value), reflectable->toDouble());
263






















































































































61
        ASSERT_EQ(zserio::toString(value), reflectable->toString());
264
265



















































































































































































































































122
        ASSERT_THROW(reflectable->getFloat(), CppRuntimeException);
266



















































































































































































































































122
        ASSERT_THROW(reflectable->getDouble(), CppRuntimeException);
267



















































































































































































































































122
        ASSERT_THROW(reflectable->getBytes(), CppRuntimeException);
268



















































































































































































































































122
        ASSERT_THROW(reflectable->getStringView(), CppRuntimeException);
269

































































































































































































































122
        ASSERT_THROW(reflectable->getBitBuffer(), CppRuntimeException);
270
271
61
        checkArithmeticCppTypeGetters(value, reflectable);
272
273
61
        checkNonCompound(reflectable);
274
61
        checkNonArray(reflectable);
275
276
61
        checkWriteRead(value, reflectable, readFunc, bitSize);
277
    }
278
279
    template <typename T, typename REFLECTABLE_PTR, typename GETTER, typename READ_FUNC>
280
31
    void checkSignedIntegral(T value, const REFLECTABLE_PTR& reflectable,
281
            const GETTER& getter, const READ_FUNC& readFunc, size_t bitSize = sizeof(T) * 8)
282
    {
283



















































31
        ASSERT_EQ(value, reflectable->toInt());
284























































































































62
        ASSERT_THROW(reflectable->toUInt(), CppRuntimeException);
285














































































































62
        ASSERT_THROW(reflectable->getBool(), CppRuntimeException); // bool is unsigned integral type
286
287
31
        checkIntegral(value, reflectable, getter, readFunc, bitSize);
288
    }
289
290
    template <typename T, typename REFLECTABLE_PTR, typename GETTER, typename READ_FUNC>
291
30
    void checkUnsignedIntegral(T value, const REFLECTABLE_PTR& reflectable,
292
            const GETTER& getter, const READ_FUNC& readFunc, size_t bitSize = sizeof(T) * 8)
293
    {
294























































30
        ASSERT_EQ(value, reflectable->toUInt());
295























































































































60
        ASSERT_THROW(reflectable->toInt(), CppRuntimeException);
296
297
30
        checkIntegral(value, reflectable, getter, readFunc, bitSize);
298
    }
299
300
    template <typename REFLECTABLE_PTR>
301
11
    void checkString(StringView value, const REFLECTABLE_PTR& reflectable)
302
    {
303







11
        ASSERT_EQ(value, reflectable->getStringView());
304
305








11
        ASSERT_EQ(value, reflectable->getAnyValue().template get<StringView>());
306
307









11
        ASSERT_EQ(toString(value), reflectable->toString());
308



















22
        ASSERT_THROW(reflectable->toInt(), CppRuntimeException);
309



















22
        ASSERT_THROW(reflectable->toUInt(), CppRuntimeException);
310



















22
        ASSERT_THROW(reflectable->toDouble(), CppRuntimeException);
311
312



















22
        ASSERT_THROW(reflectable->getBool(), CppRuntimeException);
313



















22
        ASSERT_THROW(reflectable->getInt8(), CppRuntimeException);
314



















22
        ASSERT_THROW(reflectable->getInt16(), CppRuntimeException);
315



















22
        ASSERT_THROW(reflectable->getInt32(), CppRuntimeException);
316



















22
        ASSERT_THROW(reflectable->getInt64(), CppRuntimeException);
317



















22
        ASSERT_THROW(reflectable->getUInt8(), CppRuntimeException);
318



















22
        ASSERT_THROW(reflectable->getUInt16(), CppRuntimeException);
319



















22
        ASSERT_THROW(reflectable->getUInt32(), CppRuntimeException);
320



















22
        ASSERT_THROW(reflectable->getUInt64(), CppRuntimeException);
321



















22
        ASSERT_THROW(reflectable->getFloat(), CppRuntimeException);
322



















22
        ASSERT_THROW(reflectable->getDouble(), CppRuntimeException);
323


















22
        ASSERT_THROW(reflectable->getBitBuffer(), CppRuntimeException);
324
325
11
        checkNonCompound(reflectable);
326
11
        checkNonArray(reflectable);
327
328



11
        checkWriteRead(toString(value), reflectable,
329
                std::bind(&BitStreamReader::readString<>, _1, std::allocator<uint8_t>()),
330
11
                bitSizeOfVarSize(convertSizeToUInt32(value.size())) + value.size() * 8);
331
    }
332
333
    template <typename REFLECTABLE_PTR>
334
5
    void checkBitBuffer(const BitBuffer& value, const REFLECTABLE_PTR& reflectable)
335
    {
336







5
        ASSERT_EQ(value, reflectable->getBitBuffer());
337
338









5
        ASSERT_EQ(value, reflectable->getAnyValue().
339
                template get<std::reference_wrapper<const BitBuffer>>().get());
340
341



















10
        ASSERT_THROW(reflectable->toString(), CppRuntimeException);
342



















10
        ASSERT_THROW(reflectable->toDouble(), CppRuntimeException);
343



















10
        ASSERT_THROW(reflectable->toInt(), CppRuntimeException);
344



















10
        ASSERT_THROW(reflectable->toUInt(), CppRuntimeException);
345
346



















10
        ASSERT_THROW(reflectable->getInt8(), CppRuntimeException);
347



















10
        ASSERT_THROW(reflectable->getInt16(), CppRuntimeException);
348



















10
        ASSERT_THROW(reflectable->getInt32(), CppRuntimeException);
349



















10
        ASSERT_THROW(reflectable->getInt64(), CppRuntimeException);
350



















10
        ASSERT_THROW(reflectable->getUInt8(), CppRuntimeException);
351



















10
        ASSERT_THROW(reflectable->getUInt16(), CppRuntimeException);
352



















10
        ASSERT_THROW(reflectable->getUInt32(), CppRuntimeException);
353



















10
        ASSERT_THROW(reflectable->getUInt64(), CppRuntimeException);
354



















10
        ASSERT_THROW(reflectable->getFloat(), CppRuntimeException);
355



















10
        ASSERT_THROW(reflectable->getDouble(), CppRuntimeException);
356



















10
        ASSERT_THROW(reflectable->getBytes(), CppRuntimeException);
357


















10
        ASSERT_THROW(reflectable->getStringView(), CppRuntimeException);
358
359
5
        checkNonCompound(reflectable);
360
5
        checkNonArray(reflectable);
361
362



5
        checkWriteRead(value, reflectable,
363
                std::bind(&BitStreamReader::readBitBuffer<>, _1, std::allocator<uint8_t>()),
364
5
                bitSizeOfVarSize(convertSizeToUInt32(value.getBitSize())) + value.getBitSize());
365
    }
366
367
    template <typename REFLECTABLE_PTR>
368
5
    void checkBytes(const std::vector<uint8_t>& value, const REFLECTABLE_PTR& reflectable)
369
    {
370







5
        ASSERT_EQ(value.data(), reflectable->getBytes().data());
371







5
        ASSERT_EQ(value.size(), reflectable->getBytes().size());
372


5
        auto anyValue = reflectable->getAnyValue().template get<Span<const uint8_t>>();
373






5
        ASSERT_EQ(value.data(), anyValue.data());
374







5
        ASSERT_EQ(value.size(), anyValue.size());
375
376



















10
        ASSERT_THROW(reflectable->toString(), CppRuntimeException);
377



















10
        ASSERT_THROW(reflectable->toDouble(), CppRuntimeException);
378



















10
        ASSERT_THROW(reflectable->toInt(), CppRuntimeException);
379



















10
        ASSERT_THROW(reflectable->toUInt(), CppRuntimeException);
380
381



















10
        ASSERT_THROW(reflectable->getInt8(), CppRuntimeException);
382



















10
        ASSERT_THROW(reflectable->getInt16(), CppRuntimeException);
383



















10
        ASSERT_THROW(reflectable->getInt32(), CppRuntimeException);
384



















10
        ASSERT_THROW(reflectable->getInt64(), CppRuntimeException);
385



















10
        ASSERT_THROW(reflectable->getUInt8(), CppRuntimeException);
386



















10
        ASSERT_THROW(reflectable->getUInt16(), CppRuntimeException);
387



















10
        ASSERT_THROW(reflectable->getUInt32(), CppRuntimeException);
388



















10
        ASSERT_THROW(reflectable->getUInt64(), CppRuntimeException);
389



















10
        ASSERT_THROW(reflectable->getFloat(), CppRuntimeException);
390



















10
        ASSERT_THROW(reflectable->getDouble(), CppRuntimeException);
391



















10
        ASSERT_THROW(reflectable->getStringView(), CppRuntimeException);
392


















10
        ASSERT_THROW(reflectable->getBitBuffer(), CppRuntimeException);
393
394

5
        checkNonCompound(reflectable);
395

5
        checkNonArray(reflectable);
396
397
5
        const size_t bitSize = value.size() * 8;
398



5
        checkWriteRead(value, reflectable,
399
                std::bind(&BitStreamReader::readBytes<>, _1, std::allocator<uint8_t>()),
400


5
                bitSizeOfVarSize(convertSizeToUInt32(bitSize)) + bitSize);
401
    }
402
403
    template <typename REFLECTABLE_PTR>
404
11
    void checkBitmask(ReflectableBitmask bitmask, const REFLECTABLE_PTR& reflectable)
405
    {
406







11
        ASSERT_EQ(bitmask.getValue(), reflectable->getUInt8());
407
408








11
        ASSERT_EQ(bitmask, reflectable->getAnyValue().template get<ReflectableBitmask>());
409
410







11
        ASSERT_EQ(bitmask.getValue(), reflectable->toUInt());
411







11
        ASSERT_EQ(bitmask.getValue(), reflectable->toDouble());
412









11
        ASSERT_EQ(bitmask.toString(), reflectable->toString());
413


















22
        ASSERT_THROW(reflectable->toInt(), CppRuntimeException);
414
415
11
        checkNonCompound(reflectable);
416
11
        checkNonArray(reflectable);
417
418

11
        checkWriteRead(bitmask, reflectable,
419
11
                [](BitStreamReader& reader) {
420
                    return ReflectableBitmask(reader);
421
11
                }, 8
422
        );
423
    }
424
425
    template <typename REFLECTABLE_PTR>
426
10
    void checkEnum(ReflectableEnum enumeration, const REFLECTABLE_PTR& reflectable)
427
    {
428







10
        ASSERT_EQ(enumToValue(enumeration), reflectable->getInt8());
429
430








10
        ASSERT_EQ(enumeration, reflectable->getAnyValue().template get<ReflectableEnum>());
431
432







10
        ASSERT_EQ(enumToValue(enumeration), reflectable->toInt());
433







10
        ASSERT_EQ(enumToValue(enumeration), reflectable->toDouble());
434









10
        ASSERT_EQ(enumToString(enumeration), reflectable->toString());
435


















20
        ASSERT_THROW(reflectable->toUInt(), CppRuntimeException);
436
437
10
        checkNonCompound(reflectable);
438
10
        checkNonArray(reflectable);
439
440

10
        checkWriteRead(enumeration, reflectable,
441
10
                [](BitStreamReader& reader) {
442
                    return zserio::read<ReflectableEnum>(reader);
443
10
                }, 8
444
        );
445
    }
446
447
    template <typename REFLECTABLE_PTR>
448
11
    void checkCompoundConstMethods(const ReflectableObject& reflectableObject,
449
            const REFLECTABLE_PTR& reflectable)
450
    {
451









11
        ASSERT_TRUE(TypeInfoUtil::isCompound(reflectable->getTypeInfo().getSchemaType()));
452
453
        // field getter
454











11
        ASSERT_EQ(reflectableObject.getReflectableNested().getValue(),
455
                reflectable->getField("reflectableNested")->getField("value")->getUInt32());
456




















22
        ASSERT_THROW(reflectable->getField("nonexistent"), CppRuntimeException);
457





















22
        ASSERT_THROW(reflectable->getField("reflectableNested")->getField("nonexistent"), CppRuntimeException);
458
459
        // find field
460










11
        ASSERT_EQ(reflectableObject.getReflectableNested().getValue(),
461
                reflectable->find("reflectableNested.value")->toUInt());
462










11
        ASSERT_EQ(reflectableObject.getReflectableNested().getValue(),
463
                (*reflectable)["reflectableNested.value"]->toDouble());
464
465
        // find parameter
466



















11
        ASSERT_NO_THROW(reflectable->getField("reflectableNested")->getParameter("dummyParam"));
467








11
        ASSERT_EQ(13, (*reflectable)["reflectableNested.dummyParam"]->getInt32());
468



















11
        ASSERT_NO_THROW(reflectable->getField("reflectableNested")->getParameter("stringParam"));
469









11
        ASSERT_EQ(reflectableObject.getStringField(),
470
                (*reflectable)["reflectableNested.stringParam"]->toString());
471





















22
        ASSERT_THROW(reflectable->getField("reflectableNested")->getParameter("nonexistent"),
472
                CppRuntimeException);
473
474
        // find function
475










11
        ASSERT_EQ(reflectableObject.getReflectableNested().getValue(),
476
                (*reflectable)["reflectableNested.getValue"]->getUInt32());
477





















22
        ASSERT_THROW(reflectable->getField("reflectableNested")->callFunction("nonexistent"),
478
                CppRuntimeException);
479
480
        // find failed
481







11
        ASSERT_EQ(nullptr, reflectable->find("reflectableNested.nonexistent"));
482







11
        ASSERT_EQ(nullptr, reflectable->find("nonexistent"));
483







11
        ASSERT_EQ(nullptr, reflectable->find("reflectableNested.value.nonexistent"));
484







11
        ASSERT_EQ(nullptr, reflectable->find("reflectableNested.dummyParam.nonexistent"));
485







11
        ASSERT_EQ(nullptr, reflectable->find("reflectableNested.getValue.nonexistent"));
486
        // find failed because the underlying code throws
487







11
        ASSERT_EQ(nullptr, reflectable->find("reflectableNested.throwingFunction.nonexistent"));
488
489
        if (std::is_const<typename REFLECTABLE_PTR::element_type>::value)
490
        {
491




8
            ASSERT_EQ(reflectableObject,
492
                    reflectable->getAnyValue().
493
                            template get<std::reference_wrapper<const ReflectableObject>>().get());
494





8
            ASSERT_EQ(reflectableObject.getReflectableNested(), reflectable->getField("reflectableNested")->
495
                    getAnyValue().template get<std::reference_wrapper<const ReflectableNested>>().get());
496
        }
497
        else
498
        {
499




3
            ASSERT_EQ(reflectableObject,
500
                    reflectable->getAnyValue().template get<std::reference_wrapper<ReflectableObject>>().get());
501





3
            ASSERT_EQ(reflectableObject.getReflectableNested(), reflectable->getField("reflectableNested")->
502
                    getAnyValue().template get<std::reference_wrapper<ReflectableNested>>().get());
503
        }
504
505




















22
        ASSERT_THROW(reflectable->getBool(), CppRuntimeException);
506




















22
        ASSERT_THROW(reflectable->getInt8(), CppRuntimeException);
507




















22
        ASSERT_THROW(reflectable->getInt16(), CppRuntimeException);
508




















22
        ASSERT_THROW(reflectable->getInt32(), CppRuntimeException);
509




















22
        ASSERT_THROW(reflectable->getInt64(), CppRuntimeException);
510




















22
        ASSERT_THROW(reflectable->getUInt8(), CppRuntimeException);
511




















22
        ASSERT_THROW(reflectable->getUInt16(), CppRuntimeException);
512




















22
        ASSERT_THROW(reflectable->getUInt32(), CppRuntimeException);
513




















22
        ASSERT_THROW(reflectable->getUInt64(), CppRuntimeException);
514




















22
        ASSERT_THROW(reflectable->getFloat(), CppRuntimeException);
515




















22
        ASSERT_THROW(reflectable->getDouble(), CppRuntimeException);
516




















22
        ASSERT_THROW(reflectable->getBytes(), CppRuntimeException);
517




















22
        ASSERT_THROW(reflectable->getStringView(), CppRuntimeException);
518




















22
        ASSERT_THROW(reflectable->getBitBuffer(), CppRuntimeException);
519
520




















22
        ASSERT_THROW(reflectable->toInt(), CppRuntimeException);
521




















22
        ASSERT_THROW(reflectable->toUInt(), CppRuntimeException);
522




















22
        ASSERT_THROW(reflectable->toDouble(), CppRuntimeException);
523



















22
        ASSERT_THROW(reflectable->toString(), CppRuntimeException);
524
525
11
        checkNonArray(reflectable);
526
527


11
        checkWriteRead(reflectableObject, reflectable,
528
11
                [](BitStreamReader& reader) {
529
                    return ReflectableObject(reader);
530

11
                }, reflectableObject.bitSizeOf()
531
        );
532
    }
533
534
5
    void checkCompound(const ReflectableObject& reflectableObject, const IReflectableConstPtr& reflectable)
535
    {
536
5
        checkCompoundConstMethods(reflectableObject, reflectable);
537
5
    }
538
539
3
    void checkCompound(const ReflectableObject& reflectableObject, const IReflectablePtr& reflectable)
540
    {
541
3
        checkCompoundConstMethods(reflectableObject, reflectable);
542
3
        checkCompoundConstMethods(reflectableObject, static_cast<IReflectableConstPtr>(reflectable));
543
544
        // setter
545

3
        reflectable->getField("reflectableNested")->setField("value", AnyHolder<>(static_cast<uint32_t>(11)));
546




3
        ASSERT_EQ(11, reflectableObject.getReflectableNested().getValue());
547










6
        ASSERT_THROW(reflectable->setField("nonexistent", AnyHolder<>()), CppRuntimeException);
548











6
        ASSERT_THROW(reflectable->find("reflectableNested")->setField("nonexistent", AnyHolder<>()),
549
                CppRuntimeException);
550
551
        // any value
552





3
        ASSERT_EQ(reflectableObject.getReflectableNested(), reflectable->find("reflectableNested")->
553
                getAnyValue().template get<std::reference_wrapper<ReflectableNested>>().get());
554
555
3
        reflectable->createField("reflectableNested");
556




3
        ASSERT_EQ(uint32_t(), reflectableObject.getReflectableNested().getValue());
557
558

3
        reflectable->setField("reflectableNested", AnyHolder<>(ReflectableNested{42}));
559




3
        ASSERT_EQ(42, reflectableObject.getReflectableNested().getValue());
560
3
        reflectable->initializeChildren(); // keep the reflectable initialized for following tests
561
    }
562
};
563
564


690
TEST_F(ReflectableTest, boolReflectable)
565
{
566
1
    const bool value = true;
567
2
    auto reflectable = ReflectableFactory::getBool(value);
568
3
    checkUnsignedIntegral(value, reflectable, &IReflectable::getBool,
569

3
            std::bind(&BitStreamReader::readBool, _1));
570
1
}
571
572


690
TEST_F(ReflectableTest, int8Reflectable)
573
{
574
1
    const int8_t value = -12;
575
2
    auto reflectable = ReflectableFactory::getInt8(value);
576
3
    checkSignedIntegral(value, reflectable, &IReflectable::getInt8,
577

3
            std::bind(&BitStreamReader::readSignedBits, _1, 8));
578
1
}
579
580


690
TEST_F(ReflectableTest, int16Reflectable)
581
{
582
1
    const int16_t value = -1234;
583
2
    auto reflectable = ReflectableFactory::getInt16(value);
584
3
    checkSignedIntegral(value, reflectable, &IReflectable::getInt16,
585

3
            std::bind(&BitStreamReader::readSignedBits, _1, 16));
586
1
}
587
588


690
TEST_F(ReflectableTest, int32Reflectable)
589
{
590
1
    const int32_t value = -123456;
591
2
    auto reflectable = ReflectableFactory::getInt32(value);
592
3
    checkSignedIntegral(value, reflectable, &IReflectable::getInt32,
593

3
            std::bind(&BitStreamReader::readSignedBits, _1, 32));
594
1
}
595
596


690
TEST_F(ReflectableTest, int64Reflectable)
597
{
598
1
    const int64_t value = -1234567890;
599
2
    auto reflectable = ReflectableFactory::getInt64(value);
600
3
    checkSignedIntegral(value, reflectable, &IReflectable::getInt64,
601

3
            std::bind(&BitStreamReader::readSignedBits64, _1, 64));
602
1
}
603
604


690
TEST_F(ReflectableTest, uint8Reflectable)
605
{
606
1
    const uint8_t value = 0xFF;
607
2
    auto reflectable = ReflectableFactory::getUInt8(value);
608
3
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt8,
609

3
            std::bind(&BitStreamReader::readBits, _1, 8));
610
1
}
611
612


690
TEST_F(ReflectableTest, uint16Reflectable)
613
{
614
1
    const uint16_t value = 0xFFFF;
615
2
    auto reflectable = ReflectableFactory::getUInt16(value);
616
3
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt16,
617

3
            std::bind(&BitStreamReader::readBits, _1, 16));
618
1
}
619
620


690
TEST_F(ReflectableTest, uint32Reflectable)
621
{
622
1
    const uint32_t value = 0xFFFFFFFF;
623
2
    auto reflectable = ReflectableFactory::getUInt32(value);
624
3
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt32,
625

3
            std::bind(&BitStreamReader::readBits, _1, 32));
626
1
}
627
628


690
TEST_F(ReflectableTest, uint64Reflectable)
629
{
630
1
    const uint64_t value = 0xFFFFFFFFFFFF;
631
2
    auto reflectable = ReflectableFactory::getUInt64(value);
632
3
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt64,
633

3
            std::bind(&BitStreamReader::readBits64, _1, 64));
634
1
}
635
636


690
TEST_F(ReflectableTest, fixedSignedBitField5) // mapped to int8_t
637
{
638
1
    const uint8_t numBits = 5;
639
1
    const int8_t value = 15;
640
2
    auto reflectable = ReflectableFactory::getFixedSignedBitField(numBits, value);
641
2
    checkSignedIntegral(value, reflectable, &IReflectable::getInt8,
642

3
            std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits);
643
644










2
    ASSERT_THROW(ReflectableFactory::getFixedSignedBitField(10, value), CppRuntimeException);
645
}
646
647


690
TEST_F(ReflectableTest, fixedSignedBitField15) // mapped to int16_t
648
{
649
1
    const uint8_t numBits = 15;
650
1
    const int16_t value = -15;
651
2
    auto reflectable = ReflectableFactory::getFixedSignedBitField(numBits, value);
652
2
    checkSignedIntegral(value, reflectable, &IReflectable::getInt16,
653

3
            std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits);
654
655










2
    ASSERT_THROW(ReflectableFactory::getFixedSignedBitField(5, value), CppRuntimeException);
656










2
    ASSERT_THROW(ReflectableFactory::getFixedSignedBitField(17, value), CppRuntimeException);
657
}
658
659


690
TEST_F(ReflectableTest, fixedSignedBitField31) // mapped to int32_t
660
{
661
1
    const uint8_t numBits = 31;
662
1
    const int32_t value = -12345678;
663
2
    auto reflectable = ReflectableFactory::getFixedSignedBitField(numBits, value);
664
2
    checkSignedIntegral(value, reflectable, &IReflectable::getInt32,
665

3
            std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits);
666
667










2
    ASSERT_THROW(ReflectableFactory::getFixedSignedBitField(16, value), CppRuntimeException);
668










2
    ASSERT_THROW(ReflectableFactory::getFixedSignedBitField(33, value), CppRuntimeException);
669
}
670
671


690
TEST_F(ReflectableTest, fixedSignedBitField60) // mapped to int64_t
672
{
673
1
    const uint8_t numBits = 60;
674
1
    const int64_t value = 1234567890;
675
2
    auto reflectable = ReflectableFactory::getFixedSignedBitField(numBits, value);
676
2
    checkSignedIntegral(value, reflectable, &IReflectable::getInt64,
677

3
            std::bind(&BitStreamReader::readSignedBits64, _1, numBits), numBits);
678
679










2
    ASSERT_THROW(ReflectableFactory::getFixedSignedBitField(31, value), CppRuntimeException);
680










2
    ASSERT_THROW(ReflectableFactory::getFixedSignedBitField(65, value), CppRuntimeException);
681
}
682
683


690
TEST_F(ReflectableTest, fixedUnsignedBitField7) // mapped to uint8_t
684
{
685
1
    const uint8_t numBits = 7;
686
1
    const uint8_t value = 0x2F;
687
2
    auto reflectable = ReflectableFactory::getFixedUnsignedBitField(numBits, value);
688
2
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt8,
689

3
            std::bind(&BitStreamReader::readBits, _1, numBits), numBits);
690
691










2
    ASSERT_THROW(ReflectableFactory::getFixedUnsignedBitField(9, value), CppRuntimeException);
692
}
693
694


690
TEST_F(ReflectableTest, fixedUnsignedBitField9) // mapped to uint16_t
695
{
696
1
    const uint8_t numBits = 9;
697
1
    const uint16_t value = 0x1FF;
698
2
    auto reflectable = ReflectableFactory::getFixedUnsignedBitField(numBits, value);
699
2
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt16,
700

3
            std::bind(&BitStreamReader::readBits, _1, numBits), numBits);
701
702










2
    ASSERT_THROW(ReflectableFactory::getFixedUnsignedBitField(8, value), CppRuntimeException);
703










2
    ASSERT_THROW(ReflectableFactory::getFixedUnsignedBitField(17, value), CppRuntimeException);
704
}
705
706


690
TEST_F(ReflectableTest, fixedUnsignedBitField31) // mapped to uint32_t
707
{
708
1
    const uint8_t numBits = 31;
709
1
    const uint32_t value = UINT32_MAX >> 1;
710
2
    auto reflectable = ReflectableFactory::getFixedUnsignedBitField(numBits, value);
711
2
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt32,
712

3
            std::bind(&BitStreamReader::readBits, _1, numBits), numBits);
713
714










2
    ASSERT_THROW(ReflectableFactory::getFixedUnsignedBitField(16, value), CppRuntimeException);
715










2
    ASSERT_THROW(ReflectableFactory::getFixedUnsignedBitField(33, value), CppRuntimeException);
716
}
717
718


690
TEST_F(ReflectableTest, fixedUnsignedBitField33) // mapped to uint64_t
719
{
720
1
    const uint8_t numBits = 33;
721
1
    const uint64_t value = static_cast<uint64_t>(UINT32_MAX) << 1U;
722
2
    auto reflectable = ReflectableFactory::getFixedUnsignedBitField(numBits, value);
723
2
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt64,
724

3
            std::bind(&BitStreamReader::readBits64, _1, numBits), numBits);
725
726










2
    ASSERT_THROW(ReflectableFactory::getFixedUnsignedBitField(32, value), CppRuntimeException);
727










2
    ASSERT_THROW(ReflectableFactory::getFixedUnsignedBitField(65, value), CppRuntimeException);
728
}
729
730


690
TEST_F(ReflectableTest, dynamicSignedBitField5) // mapped to int8_t
731
{
732
1
    const uint8_t maxBitSize = 8;
733
1
    const uint8_t numBits = 5;
734
1
    const int8_t value = 15;
735
2
    auto reflectable = ReflectableFactory::getDynamicSignedBitField(maxBitSize, value, numBits);
736
2
    checkSignedIntegral(value, reflectable, &IReflectable::getInt8,
737

3
            std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits);
738
739










2
    ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(9, value, numBits), CppRuntimeException);
740
}
741
742


690
TEST_F(ReflectableTest, dynamicSignedBitField15) // mapped to int16_t
743
{
744
1
    const uint8_t maxBitSize = 16;
745
1
    const uint8_t numBits = 15;
746
1
    const int16_t value = -15;
747
2
    auto reflectable = ReflectableFactory::getDynamicSignedBitField(maxBitSize, value, numBits);
748
2
    checkSignedIntegral(value, reflectable, &IReflectable::getInt16,
749

3
            std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits);
750
751










2
    ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(8, value, numBits), CppRuntimeException);
752










2
    ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(17, value, numBits), CppRuntimeException);
753
}
754
755


690
TEST_F(ReflectableTest, dynamicSignedBitField31) // mapped to int32_t
756
{
757
1
    const uint8_t maxBitSize = 32;
758
1
    const uint8_t numBits = 31;
759
1
    const int32_t value = -12345678;
760
2
    auto reflectable = ReflectableFactory::getDynamicSignedBitField(maxBitSize, value, numBits);
761
2
    checkSignedIntegral(value, reflectable, &IReflectable::getInt32,
762

3
            std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits);
763
764










2
    ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(16, value, numBits), CppRuntimeException);
765










2
    ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(33, value, numBits), CppRuntimeException);
766
}
767
768


690
TEST_F(ReflectableTest, dynamicSignedBitField60) // mapped to int64_t
769
{
770
1
    const uint8_t maxBitSize = 64;
771
1
    const uint8_t numBits = 60;
772
1
    const int64_t value = 1234567890;
773
2
    auto reflectable = ReflectableFactory::getDynamicSignedBitField(maxBitSize, value, numBits);
774
2
    checkSignedIntegral(value, reflectable, &IReflectable::getInt64,
775

3
            std::bind(&BitStreamReader::readSignedBits64, _1, numBits), numBits);
776
777










2
    ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(32, value, numBits), CppRuntimeException);
778










2
    ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(65, value, numBits), CppRuntimeException);
779
}
780
781


690
TEST_F(ReflectableTest, dynamicUnsignedBitField7) // mapped to uint8_t
782
{
783
1
    const uint8_t maxBitSize = 8;
784
1
    const uint8_t numBits = 7;
785
1
    const uint8_t value = 0x2F;
786
2
    auto reflectable = ReflectableFactory::getDynamicUnsignedBitField(maxBitSize, value, numBits);
787
2
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt8,
788

3
            std::bind(&BitStreamReader::readBits, _1, numBits), numBits);
789
790










2
    ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(9, value, numBits), CppRuntimeException);
791
}
792
793


690
TEST_F(ReflectableTest, dynamicUnsignedBitField9) // mapped to uint16_t
794
{
795
1
    const uint8_t maxBitSize = 16;
796
1
    const uint8_t numBits = 9;
797
1
    const uint16_t value = 0x1FF;
798
2
    auto reflectable = ReflectableFactory::getDynamicUnsignedBitField(maxBitSize, value, numBits);
799
2
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt16,
800

3
            std::bind(&BitStreamReader::readBits, _1, numBits), numBits);
801
802










2
    ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(8, value, numBits), CppRuntimeException);
803










2
    ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(17, value, numBits), CppRuntimeException);
804
}
805
806


690
TEST_F(ReflectableTest, dynamicUnsignedBitField31) // mapped to uint32_t
807
{
808
1
    const uint8_t maxBitSize = 32;
809
1
    const uint8_t numBits = 31;
810
1
    const uint32_t value = UINT32_MAX >> 1;
811
2
    auto reflectable = ReflectableFactory::getDynamicUnsignedBitField(maxBitSize, value, numBits);
812
2
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt32,
813

3
            std::bind(&BitStreamReader::readBits, _1, numBits), numBits);
814
815










2
    ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(16, value, numBits), CppRuntimeException);
816










2
    ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(33, value, numBits), CppRuntimeException);
817
}
818
819


690
TEST_F(ReflectableTest, dynamicUnsignedBitField33) // mapped to uint64_t
820
{
821
1
    const uint8_t maxBitSize = 64;
822
1
    const uint8_t numBits = 33;
823
1
    const uint64_t value = static_cast<uint64_t>(UINT32_MAX) << 1U;
824
2
    auto reflectable = ReflectableFactory::getDynamicUnsignedBitField(maxBitSize, value, numBits);
825
2
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt64,
826

3
            std::bind(&BitStreamReader::readBits64, _1, numBits), numBits);
827
828










2
    ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(32, value, numBits), CppRuntimeException);
829










2
    ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(65, value, numBits), CppRuntimeException);
830
}
831
832


690
TEST_F(ReflectableTest, varint16Reflectable)
833
{
834
1
    const int16_t value = -1234;
835
2
    auto reflectable = ReflectableFactory::getVarInt16(value);
836
3
    checkSignedIntegral(value, reflectable, &IReflectable::getInt16,
837

3
            std::bind(&BitStreamReader::readVarInt16, _1), bitSizeOfVarInt16(value));
838
1
}
839
840


690
TEST_F(ReflectableTest, varint32Reflectable)
841
{
842
1
    const int32_t value = 54321;
843
2
    auto reflectable = ReflectableFactory::getVarInt32(value);
844
3
    checkSignedIntegral(value, reflectable, &IReflectable::getInt32,
845

3
            std::bind(&BitStreamReader::readVarInt32, _1), bitSizeOfVarInt32(value));
846
1
}
847
848


690
TEST_F(ReflectableTest, varint64Reflectable)
849
{
850
1
    const int64_t value = -87654321;
851
2
    auto reflectable = ReflectableFactory::getVarInt64(value);
852
3
    checkSignedIntegral(value, reflectable, &IReflectable::getInt64,
853

3
            std::bind(&BitStreamReader::readVarInt64, _1), bitSizeOfVarInt64(value));
854
1
}
855
856


690
TEST_F(ReflectableTest, varintReflectable)
857
{
858
1
    const int64_t value = INT64_MAX;
859
2
    auto reflectable = ReflectableFactory::getVarInt(value);
860
3
    checkSignedIntegral(value, reflectable, &IReflectable::getInt64,
861

3
            std::bind(&BitStreamReader::readVarInt, _1), bitSizeOfVarInt(value));
862
1
}
863
864


690
TEST_F(ReflectableTest, varuint16Reflectable)
865
{
866
1
    const uint16_t value = 1234;
867
2
    auto reflectable = ReflectableFactory::getVarUInt16(value);
868
3
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt16,
869

3
            std::bind(&BitStreamReader::readVarUInt16, _1), bitSizeOfVarUInt16(value));
870
1
}
871
872


690
TEST_F(ReflectableTest, varuint32Reflectable)
873
{
874
1
    const uint32_t value = 0x1FFFFFFF;
875
2
    auto reflectable = ReflectableFactory::getVarUInt32(value);
876
3
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt32,
877

3
            std::bind(&BitStreamReader::readVarUInt32, _1), bitSizeOfVarUInt32(value));
878
1
}
879
880


690
TEST_F(ReflectableTest, varuint64Reflectable)
881
{
882
1
    const uint64_t value = 4242424242;
883
2
    auto reflectable = ReflectableFactory::getVarUInt64(value);
884
3
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt64,
885

3
            std::bind(&BitStreamReader::readVarUInt64, _1), bitSizeOfVarUInt64(value));
886
1
}
887
888


690
TEST_F(ReflectableTest, varuintReflectable)
889
{
890
1
    const uint64_t value = UINT64_MAX;
891
2
    auto reflectable = ReflectableFactory::getVarUInt(value);
892
3
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt64,
893

3
            std::bind(&BitStreamReader::readVarUInt, _1), bitSizeOfVarUInt(value));
894
1
}
895
896


690
TEST_F(ReflectableTest, varsizeReflectable)
897
{
898
1
    const uint32_t value = (UINT32_C(1) << (7+7+7+7+3)) - 1;
899
2
    auto reflectable = ReflectableFactory::getVarSize(value);
900
3
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt32,
901

3
            std::bind(&BitStreamReader::readVarSize, _1), bitSizeOfVarSize(value));
902
1
}
903
904


690
TEST_F(ReflectableTest, float16Reflectable)
905
{
906
1
    const float value = 2.0F;
907
2
    auto reflectable = ReflectableFactory::getFloat16(value);
908
3
    checkFloatingPoint(value, reflectable, &IReflectable::getFloat,
909

3
            std::bind(&BitStreamReader::readFloat16, _1));
910
1
}
911
912


690
TEST_F(ReflectableTest, float32Reflectable)
913
{
914
1
    const float value = 1.2F;
915
2
    auto reflectable = ReflectableFactory::getFloat32(value);
916
3
    checkFloatingPoint(value, reflectable, &IReflectable::getFloat,
917

3
            std::bind(&BitStreamReader::readFloat32, _1));
918
1
}
919
920


690
TEST_F(ReflectableTest, float64Reflectable)
921
{
922
1
    const double value = 1.2;
923
2
    auto reflectable = ReflectableFactory::getFloat64(value);
924
3
    checkFloatingPoint(value, reflectable, &IReflectable::getDouble,
925

3
            std::bind(&BitStreamReader::readFloat64, _1));
926
1
}
927
928


690
TEST_F(ReflectableTest, stringReflectable)
929
{
930
2
    const std::string value = "some longer string value to have a chance that some allocation hopefully occurs";
931
2
    auto reflectable = ReflectableFactory::getString(value);
932
1
    checkString(value, reflectable);
933
1
}
934
935


690
TEST_F(ReflectableTest, stringViewReflectable)
936
{
937
1
    auto view = makeStringView("some text as a string view");
938
2
    auto reflectable = ReflectableFactory::getString(view);
939
1
    checkString(view, reflectable);
940
1
}
941
942


690
TEST_F(ReflectableTest, bitBufferReflectable)
943
{
944

2
    const BitBuffer value = BitBuffer{std::vector<uint8_t>({0xAB, 0xF0}), 12};
945
2
    auto reflectable = ReflectableFactory::getBitBuffer(value);
946
1
    checkBitBuffer(value, reflectable);
947
1
}
948
949


690
TEST_F(ReflectableTest, bytesReflectable)
950
{
951
2
    const vector<uint8_t> value{{0, 127, 128, 255}};
952

2
    auto reflectable = ReflectableFactory::getBytes(value);
953
1
    checkBytes(value, reflectable);
954
1
}
955
956


690
TEST_F(ReflectableTest, uint8ConstArray)
957
{
958
2
    const auto rawArray = std::vector<uint8_t>({10, 20, 30, 40});
959
1
    const ITypeInfo& typeInfo = BuiltinTypeInfo<>::getUInt8();
960

2
    auto reflectable = ReflectableFactory::getBuiltinArray(typeInfo, rawArray);
961
2
    checkArray(rawArray, reflectable,
962
4
            [&](uint8_t value, const IReflectableConstPtr& elementReflectable) {
963
16
                checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt8,
964

16
                        std::bind(&BitStreamReader::readBits, _1, 8));
965
4
            }
966
1
    );
967
968
2
    auto nonConstReflectable = std::const_pointer_cast<IReflectable>(reflectable);
969









2
    ASSERT_THROW(nonConstReflectable->getAnyValue(), CppRuntimeException);
970
971
    // call version with dynamic bit size
972










2
    ASSERT_THROW(ReflectableFactory::getBuiltinArray(typeInfo, rawArray, 8), CppRuntimeException);
973
}
974
975


690
TEST_F(ReflectableTest, uint8Array)
976
{
977
2
    auto rawArray = std::vector<uint8_t>{{10, 20, 30, 40}};
978
1
    const ITypeInfo& typeInfo = BuiltinTypeInfo<>::getUInt8();
979

2
    auto reflectable = ReflectableFactory::getBuiltinArray(typeInfo, rawArray);
980
2
    checkArray(rawArray, reflectable,
981
4
            [&](uint8_t value, const IReflectablePtr& elementReflectable) {
982
16
                checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt8,
983

16
                        std::bind(&BitStreamReader::readBits, _1, 8));
984
4
            }
985
1
    );
986
2
    checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable),
987
4
            [&](uint8_t value, const IReflectableConstPtr& elementReflectable) {
988
16
                checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt8,
989

16
                        std::bind(&BitStreamReader::readBits, _1, 8));
990
4
            }
991
1
    );
992
993
    // call version with dynamic bit size
994










2
    ASSERT_THROW(ReflectableFactory::getBuiltinArray(typeInfo, rawArray, 8), CppRuntimeException);
995
996
1
    reflectable->resize(0);
997



1
    ASSERT_EQ(0, reflectable->size());
998

1
    reflectable->append(AnyHolder<>(static_cast<uint8_t>(13)));
999



1
    ASSERT_EQ(1, reflectable->size());
1000




1
    ASSERT_EQ(13, reflectable->at(0)->getUInt8());
1001

1
    reflectable->setAt(AnyHolder<>(static_cast<uint8_t>(42)), 0);
1002



1
    ASSERT_EQ(1, reflectable->size());
1003




1
    ASSERT_EQ(42, reflectable->at(0)->getUInt8());
1004
1
    reflectable->resize(2);
1005



1
    ASSERT_EQ(2, reflectable->size());
1006
1007
    // out of range
1008











2
    ASSERT_THROW(reflectable->setAt(AnyHolder<>(static_cast<uint8_t>(42)), 2), CppRuntimeException);
1009
}
1010
1011


690
TEST_F(ReflectableTest, dynamicSignedBitField5ConstArray)
1012
{
1013
1
    const uint8_t maxBitSize = 8;
1014
1
    const uint8_t numBits = 5;
1015
2
    const auto rawArray = std::vector<int8_t>{{-3, -1, 2, 4, 6}};
1016
1
    const ITypeInfo& typeInfo = BuiltinTypeInfo<>::getDynamicSignedBitField(maxBitSize);
1017

2
    auto reflectable = ReflectableFactory::getBuiltinArray(typeInfo, rawArray, numBits);
1018
2
    checkArray(rawArray, reflectable,
1019
5
            [&](int8_t value, const IReflectableConstPtr& elementReflectable) {
1020
15
                checkSignedIntegral(value, elementReflectable, &IReflectable::getInt8,
1021

20
                        std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits);
1022
5
            }
1023
1
    );
1024
1025
2
    auto nonConstReflectable = std::const_pointer_cast<IReflectable>(reflectable);
1026









2
    ASSERT_THROW(nonConstReflectable->getAnyValue(), CppRuntimeException);
1027
1028
    // call version without dynamic bit size
1029










2
    ASSERT_THROW(ReflectableFactory::getBuiltinArray(typeInfo, rawArray), CppRuntimeException);
1030
}
1031
1032


690
TEST_F(ReflectableTest, dynamicSignedBitField5Array)
1033
{
1034
1
    const uint8_t maxBitSize = 8;
1035
1
    const uint8_t numBits = 5;
1036
2
    auto rawArray = std::vector<int8_t>{{-3, -1, 2, 4, 6}};
1037
1
    const ITypeInfo& typeInfo = BuiltinTypeInfo<>::getDynamicSignedBitField(maxBitSize);
1038

2
    auto reflectable = ReflectableFactory::getBuiltinArray(typeInfo, rawArray, numBits);
1039
2
    checkArray(rawArray, reflectable,
1040
5
            [&](int8_t value, const IReflectablePtr& elementReflectable) {
1041
15
                checkSignedIntegral(value, elementReflectable, &IReflectable::getInt8,
1042

20
                        std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits);
1043
5
            }
1044
1
    );
1045
2
    checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable),
1046
5
            [&](int8_t value, const IReflectableConstPtr& elementReflectable) {
1047
15
                checkSignedIntegral(value, elementReflectable, &IReflectable::getInt8,
1048

20
                        std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits);
1049
5
            }
1050
1
    );
1051
1052
    // call version without dynamic bit size
1053










2
    ASSERT_THROW(ReflectableFactory::getBuiltinArray(typeInfo, rawArray), CppRuntimeException);
1054
1055
1
    reflectable->resize(0);
1056



1
    ASSERT_EQ(0, reflectable->size());
1057

1
    reflectable->append(AnyHolder<>(static_cast<int8_t>(13)));
1058



1
    ASSERT_EQ(1, reflectable->size());
1059




1
    ASSERT_EQ(13, reflectable->at(0)->getInt8());
1060

1
    reflectable->setAt(AnyHolder<>(static_cast<int8_t>(42)), 0);
1061



1
    ASSERT_EQ(1, reflectable->size());
1062




1
    ASSERT_EQ(42, reflectable->at(0)->getInt8());
1063
1
    reflectable->resize(2);
1064



1
    ASSERT_EQ(2, reflectable->size());
1065
1066
    // out of range
1067











2
    ASSERT_THROW(reflectable->setAt(AnyHolder<>(static_cast<int8_t>(42)), 2), CppRuntimeException);
1068
}
1069
1070


690
TEST_F(ReflectableTest, stringConstArray)
1071
{
1072



2
    const auto rawArray = std::vector<std::string>{{"one", "two", "three"}};
1073

2
    auto reflectable = ReflectableFactory::getBuiltinArray(BuiltinTypeInfo<>::getString(), rawArray);
1074
2
    checkArray(rawArray, reflectable,
1075
3
            [&](StringView value, const IReflectableConstPtr& elementReflectable) {
1076
3
                checkString(value, elementReflectable);
1077
3
            }
1078
1
    );
1079
1080
2
    auto nonConstReflectable = std::const_pointer_cast<IReflectable>(reflectable);
1081










2
    ASSERT_THROW(nonConstReflectable->getAnyValue(), CppRuntimeException);
1082
}
1083
1084


690
TEST_F(ReflectableTest, stringArray)
1085
{
1086



2
    auto rawArray = std::vector<std::string>{{"one", "two", "three"}};
1087

2
    auto reflectable = ReflectableFactory::getBuiltinArray(BuiltinTypeInfo<>::getString(), rawArray);
1088
2
    checkArray(rawArray, reflectable,
1089
3
            [&](StringView value, const IReflectablePtr& elementReflectable) {
1090
3
                checkString(value, elementReflectable);
1091
3
            }
1092
1
    );
1093
2
    checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable),
1094
3
            [&](StringView value, const IReflectableConstPtr& elementReflectable) {
1095
3
                checkString(value, elementReflectable);
1096
3
            }
1097
1
    );
1098
1099
1
    reflectable->resize(0);
1100



1
    ASSERT_EQ(0, reflectable->size());
1101

1
    reflectable->append(AnyHolder<>(std::string("appended")));
1102



1
    ASSERT_EQ(1, reflectable->size());
1103




1
    ASSERT_EQ("appended"_sv, reflectable->at(0)->getStringView());
1104

1
    reflectable->setAt(AnyHolder<>(std::string("set")), 0);
1105



1
    ASSERT_EQ(1, reflectable->size());
1106




1
    ASSERT_EQ("set"_sv, reflectable->at(0)->getStringView());
1107
1
    reflectable->resize(2);
1108



1
    ASSERT_EQ(2, reflectable->size());
1109
1110
    // out of range
1111











2
    ASSERT_THROW(reflectable->setAt(AnyHolder<>(std::string("set")), 2), CppRuntimeException);
1112
}
1113
1114


690
TEST_F(ReflectableTest, bitBufferArray)
1115
{
1116



2
    auto rawArray = std::vector<BitBuffer>{{BitBuffer({0xF8}, 5), BitBuffer({0xAB, 0xCD}, 16)}};
1117

2
    auto reflectable = ReflectableFactory::getBuiltinArray(BuiltinTypeInfo<>::getBitBuffer(), rawArray);
1118
2
    checkArray(rawArray, reflectable,
1119
2
            [&](const BitBuffer& value, const IReflectablePtr& elementReflectable) {
1120
2
                checkBitBuffer(value, elementReflectable);
1121
2
            }
1122
1
    );
1123
2
    checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable),
1124
2
            [&](const BitBuffer& value, const IReflectableConstPtr& elementReflectable) {
1125
2
                checkBitBuffer(value, elementReflectable);
1126
2
            }
1127
1
    );
1128
1129
1
    reflectable->resize(0);
1130



1
    ASSERT_EQ(0, reflectable->size());
1131

1
    reflectable->append(AnyHolder<>(BitBuffer()));
1132



1
    ASSERT_EQ(1, reflectable->size());
1133




1
    ASSERT_EQ(0, reflectable->at(0)->getBitBuffer().getBitSize());
1134


1
    reflectable->setAt(AnyHolder<>(BitBuffer({0xA0}, 4)), 0);
1135



1
    ASSERT_EQ(1, reflectable->size());
1136




1
    ASSERT_EQ(4, reflectable->at(0)->getBitBuffer().getBitSize());
1137
1
    reflectable->resize(2);
1138



1
    ASSERT_EQ(2, reflectable->size());
1139
1140
    // out of range
1141











2
    ASSERT_THROW(reflectable->setAt(AnyHolder<>(BitBuffer()), 2), CppRuntimeException);
1142
}
1143
1144


690
TEST_F(ReflectableTest, bytesArray)
1145
{
1146
    auto rawArray = std::vector<std::vector<uint8_t>>{{
1147
        {{0x00, 0x01}},
1148
        {{0xFF, 0xFE}}
1149


2
    }};
1150

2
    auto reflectable = ReflectableFactory::getBuiltinArray(BuiltinTypeInfo<>::getBytes(), rawArray);
1151
2
    checkArray(rawArray, reflectable,
1152
2
            [&](const vector<uint8_t>& value, const IReflectablePtr& elementReflectable) {
1153
1154
2
                checkBytes(value, elementReflectable);
1155
2
            }
1156
1
    );
1157
2
    checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable),
1158
2
            [&](const vector<uint8_t>& value, const IReflectableConstPtr& elementReflectable) {
1159
1160
2
                checkBytes(value, elementReflectable);
1161
2
            }
1162
1
    );
1163
1164
1
    reflectable->resize(0);
1165



1
    ASSERT_EQ(0, reflectable->size());
1166

1
    reflectable->append(AnyHolder<>(std::vector<uint8_t>()));
1167



1
    ASSERT_EQ(1, reflectable->size());
1168




1
    ASSERT_EQ(0, reflectable->at(0)->getBytes().size());
1169

1
    reflectable->setAt(AnyHolder<>(std::vector<uint8_t>{{0xAB, 0xCD}}), 0);
1170



1
    ASSERT_EQ(1, reflectable->size());
1171




1
    ASSERT_EQ(2, reflectable->at(0)->getBytes().size());
1172
1
    reflectable->resize(2);
1173



1
    ASSERT_EQ(2, reflectable->size());
1174
1175
    // out of range
1176











2
    ASSERT_THROW(reflectable->setAt(AnyHolder<>(std::vector<uint8_t>()), 2), CppRuntimeException);
1177
}
1178
1179


690
TEST_F(ReflectableTest, bitmaskConst)
1180
{
1181
1
    const ReflectableBitmask bitmask = ReflectableBitmask::Values::WRITE;
1182
2
    auto reflectable = bitmask.reflectable();
1183
1
    checkBitmask(bitmask, reflectable);
1184
1
}
1185
1186


690
TEST_F(ReflectableTest, bitmask)
1187
{
1188
1
    ReflectableBitmask bitmask = ReflectableBitmask::Values::WRITE;
1189
2
    auto reflectable = bitmask.reflectable();
1190
1
    checkBitmask(bitmask, reflectable);
1191
1
}
1192
1193


690
TEST_F(ReflectableTest, bitmaskConstArray)
1194
{
1195
    const auto rawArray = std::vector<ReflectableBitmask>{{
1196
            ReflectableBitmask::Values::WRITE, ReflectableBitmask::Values::CREATE,
1197
            ReflectableBitmask::Values::READ
1198
2
    }};
1199

2
    auto reflectable = ReflectableFactory::getBitmaskArray(rawArray);
1200
2
    checkArray(rawArray, reflectable,
1201
3
            [&](ReflectableBitmask value, const IReflectableConstPtr& elementReflectable) {
1202
3
                checkBitmask(value, elementReflectable);
1203
3
            }
1204
1
    );
1205
1206
2
    auto nonConstReflectable = std::const_pointer_cast<IReflectable>(reflectable);
1207










2
    ASSERT_THROW(nonConstReflectable->getAnyValue(), CppRuntimeException);
1208
}
1209
1210


690
TEST_F(ReflectableTest, bitmaskArray)
1211
{
1212
    auto rawArray = std::vector<ReflectableBitmask>{{
1213
            ReflectableBitmask::Values::WRITE, ReflectableBitmask::Values::CREATE,
1214
            ReflectableBitmask::Values::READ
1215
2
    }};
1216

2
    auto reflectable = ReflectableFactory::getBitmaskArray(rawArray);
1217
2
    checkArray(rawArray, reflectable,
1218
3
            [&](ReflectableBitmask value, const IReflectablePtr& elementReflectable) {
1219
3
                checkBitmask(value, elementReflectable);
1220
3
            }
1221
1
    );
1222
2
    checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable),
1223
3
            [&](ReflectableBitmask value, const IReflectableConstPtr& elementReflectable) {
1224
3
                checkBitmask(value, elementReflectable);
1225
3
            }
1226
1
    );
1227
1228
1
    reflectable->resize(0);
1229



1
    ASSERT_EQ(0, reflectable->size());
1230

1
    reflectable->append(AnyHolder<>(ReflectableBitmask(ReflectableBitmask::Values::READ)));
1231



1
    ASSERT_EQ(1, reflectable->size());
1232




1
    ASSERT_EQ(ReflectableBitmask::Values::READ, ReflectableBitmask(reflectable->at(0)->getUInt8()));
1233

1
    reflectable->setAt(AnyHolder<>(ReflectableBitmask(ReflectableBitmask::Values::CREATE)), 0);
1234



1
    ASSERT_EQ(1, reflectable->size());
1235




1
    ASSERT_EQ(ReflectableBitmask::Values::CREATE, ReflectableBitmask(reflectable->at(0)->getUInt8()));
1236
1
    reflectable->resize(2);
1237



1
    ASSERT_EQ(2, reflectable->size());
1238
1239

1
    reflectable->append(AnyHolder<>(ReflectableBitmask(ReflectableBitmask::Values::WRITE).getValue()));
1240



1
    ASSERT_EQ(3, reflectable->size());
1241




1
    ASSERT_EQ(ReflectableBitmask::Values::WRITE, ReflectableBitmask(reflectable->at(2)->getUInt8()));
1242

1
    reflectable->setAt(AnyHolder<>(ReflectableBitmask(ReflectableBitmask::Values::READ).getValue()), 2);
1243



1
    ASSERT_EQ(3, reflectable->size());
1244




1
    ASSERT_EQ(ReflectableBitmask::Values::READ, ReflectableBitmask(reflectable->at(2)->getUInt8()));
1245
1246
    // out of range
1247











2
    ASSERT_THROW(reflectable->setAt(AnyHolder<>(ReflectableBitmask::Values::CREATE), 3), CppRuntimeException);
1248
}
1249
1250


690
TEST_F(ReflectableTest, enumeration)
1251
{
1252
1
    const ReflectableEnum enumeration = ReflectableEnum::VALUE1;
1253
2
    auto reflectable = enumReflectable(enumeration);
1254
1
    checkEnum(enumeration, reflectable);
1255
1
}
1256
1257


690
TEST_F(ReflectableTest, enumConstArray)
1258
{
1259
    const auto rawArray = std::vector<ReflectableEnum>{{ReflectableEnum::VALUE1, ReflectableEnum::VALUE2,
1260
2
            ReflectableEnum::VALUE3}};
1261

2
    auto reflectable = ReflectableFactory::getEnumArray(rawArray);
1262
2
    checkArray(rawArray, reflectable,
1263
3
            [&](ReflectableEnum value, const IReflectableConstPtr& elementReflectable) {
1264
3
                checkEnum(value, elementReflectable);
1265
3
            }
1266
1
    );
1267
1268
2
    auto nonConstReflectable = std::const_pointer_cast<IReflectable>(reflectable);
1269










2
    ASSERT_THROW(nonConstReflectable->getAnyValue(), CppRuntimeException);
1270
}
1271
1272


690
TEST_F(ReflectableTest, enumArray)
1273
{
1274
    auto rawArray = std::vector<ReflectableEnum>{{ReflectableEnum::VALUE1, ReflectableEnum::VALUE2,
1275
2
            ReflectableEnum::VALUE3}};
1276

2
    auto reflectable = ReflectableFactory::getEnumArray(rawArray);
1277
2
    checkArray(rawArray, reflectable,
1278
3
            [&](ReflectableEnum value, const IReflectablePtr& elementReflectable) {
1279
3
                checkEnum(value, elementReflectable);
1280
3
            }
1281
1
    );
1282
2
    checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable),
1283
3
            [&](ReflectableEnum value, const IReflectableConstPtr& elementReflectable) {
1284
3
                checkEnum(value, elementReflectable);
1285
3
            }
1286
1
    );
1287
1288
1
    reflectable->resize(0);
1289



1
    ASSERT_EQ(0, reflectable->size());
1290

1
    reflectable->append(AnyHolder<>(ReflectableEnum::VALUE3));
1291



1
    ASSERT_EQ(1, reflectable->size());
1292




1
    ASSERT_EQ(enumToValue(ReflectableEnum::VALUE3), reflectable->at(0)->getInt8());
1293

1
    reflectable->setAt(AnyHolder<>(ReflectableEnum::VALUE2), 0);
1294



1
    ASSERT_EQ(1, reflectable->size());
1295




1
    ASSERT_EQ(enumToValue(ReflectableEnum::VALUE2), reflectable->at(0)->getInt8());
1296
1
    reflectable->resize(2);
1297



1
    ASSERT_EQ(2, reflectable->size());
1298
1299

1
    reflectable->append(AnyHolder<>(enumToValue(ReflectableEnum::VALUE1)));
1300



1
    ASSERT_EQ(3, reflectable->size());
1301




1
    ASSERT_EQ(enumToValue(ReflectableEnum::VALUE1), reflectable->at(2)->getInt8());
1302

1
    reflectable->setAt(AnyHolder<>(enumToValue(ReflectableEnum::VALUE2)), 2);
1303



1
    ASSERT_EQ(3, reflectable->size());
1304




1
    ASSERT_EQ(enumToValue(ReflectableEnum::VALUE2), reflectable->at(2)->getInt8());
1305
1306
    // out of range
1307











2
    ASSERT_THROW(reflectable->setAt(AnyHolder<>(ReflectableEnum::VALUE2), 3), CppRuntimeException);
1308
}
1309
1310


690
TEST_F(ReflectableTest, compoundConst)
1311
{
1312
    {
1313
        const ReflectableObject reflectableObjectUninitialized = ReflectableObject{"test",
1314
2
                ReflectableNested{13}};
1315

2
        auto reflectable = reflectableObjectUninitialized.reflectable();
1316




1
        ASSERT_FALSE(reflectable->find("reflectableNested.stringParam"));
1317
    }
1318
1319

2
    const ReflectableObject reflectableObject = createInitializedReflectableObject("test", 13);
1320

2
    auto reflectable = reflectableObject.reflectable();
1321
1
    checkCompound(reflectableObject, reflectable);
1322
1323
2
    IReflectablePtr nonConstReflectable = std::const_pointer_cast<IReflectable>(reflectable);
1324









2
    ASSERT_THROW(nonConstReflectable->initializeChildren(), CppRuntimeException);
1325










2
    ASSERT_THROW(nonConstReflectable->initialize(vector<AnyHolder<>>()), CppRuntimeException);
1326









1
    ASSERT_NO_THROW(reflectable->getField("reflectableNested"));
1327










2
    ASSERT_THROW(nonConstReflectable->getField("reflectableNested"), CppRuntimeException);
1328









1
    ASSERT_NO_THROW(reflectable->getAnyValue());
1329









2
    ASSERT_THROW(nonConstReflectable->getAnyValue(), CppRuntimeException);
1330
1331

2
    IReflectableConstPtr childReflectable = reflectable->getField("reflectableNested");
1332
2
    IReflectablePtr nonConstChildReflectable =std::const_pointer_cast<IReflectable>(childReflectable);
1333










2
    ASSERT_THROW(nonConstChildReflectable->setField("value", AnyHolder<>(static_cast<uint32_t>(11))),
1334
            CppRuntimeException);
1335









1
    ASSERT_NO_THROW(childReflectable->getParameter("dummyParam"));
1336










2
    ASSERT_THROW(nonConstChildReflectable->getParameter("dummyParam"), CppRuntimeException);
1337









1
    ASSERT_NO_THROW(childReflectable->callFunction("getValue"));
1338











2
    ASSERT_THROW(nonConstChildReflectable->callFunction("getValue"), CppRuntimeException);
1339










2
    ASSERT_THROW(nonConstChildReflectable->initializeOffsets(0), CppRuntimeException);
1340
}
1341
1342


690
TEST_F(ReflectableTest, compound)
1343
{
1344
2
    ReflectableObject reflectableObject = ReflectableObject{"test", ReflectableNested{13}};
1345

2
    auto reflectable = reflectableObject.reflectable();
1346
1347
    // not initialized
1348










2
    ASSERT_THROW(reflectable->getField("reflectableNested")->getParameter("dummyParam"), CppRuntimeException);
1349










2
    ASSERT_THROW(reflectable->getField("reflectableNested")->getParameter("stringParam"), CppRuntimeException);
1350



1
    ASSERT_FALSE(static_cast<IReflectableConstPtr>(reflectable)->find("reflectableNested.stringParam"));
1351
1352
1
    reflectable->initializeChildren();
1353

1
    checkCompound(reflectableObject, reflectable);
1354
}
1355
1356


690
TEST_F(ReflectableTest, compoundConstArray)
1357
{
1358
2
    ReflectableObject reflectableObject1;
1359

1
    reflectableObject1 = createInitializedReflectableObject("1", 13); // to cover assignment operator
1360
    const auto rawArray = std::vector<ReflectableObject>{{
1361
        reflectableObject1,
1362
        createInitializedReflectableObject("2", 42)
1363



2
    }};
1364

2
    auto reflectable = ReflectableFactory::getCompoundArray(rawArray);
1365
2
    checkArray(rawArray, reflectable,
1366
2
            [&](const ReflectableObject& value, const IReflectableConstPtr& elementReflectable) {
1367
2
                checkCompound(value, elementReflectable);
1368
2
            }
1369
1
    );
1370
1371
2
    IReflectablePtr nonConstReflectable = std::const_pointer_cast<IReflectable>(reflectable);
1372










2
    ASSERT_THROW(nonConstReflectable->at(0), CppRuntimeException);
1373










2
    ASSERT_THROW((*nonConstReflectable)[0], CppRuntimeException);
1374










2
    ASSERT_THROW(nonConstReflectable->resize(nonConstReflectable->size() + 1), CppRuntimeException);
1375











2
    ASSERT_THROW(nonConstReflectable->setAt(AnyHolder<>(ReflectableObject{"test", ReflectableNested{0}}), 0),
1376
            CppRuntimeException);
1377












2
    ASSERT_THROW(nonConstReflectable->append(AnyHolder<>(ReflectableObject{"test", ReflectableNested{0}})),
1378
            CppRuntimeException);
1379










2
    ASSERT_THROW(nonConstReflectable->getAnyValue(), CppRuntimeException);
1380
}
1381
1382


690
TEST_F(ReflectableTest, compoundArray)
1383
{
1384
    auto rawArray = std::vector<ReflectableObject>{{
1385
        createInitializedReflectableObject("1", 13),
1386
        createInitializedReflectableObject("2", 42)
1387



2
    }};
1388

2
    auto reflectable = ReflectableFactory::getCompoundArray(rawArray);
1389
2
    checkArray(rawArray, reflectable,
1390
2
            [&](const ReflectableObject& value, const IReflectablePtr& elementReflectable) {
1391
2
                checkCompound(value, elementReflectable);
1392
2
            }
1393
1
    );
1394
2
    checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable),
1395
2
            [&](const ReflectableObject& value, const IReflectableConstPtr& elementReflectable) {
1396
2
                checkCompound(value, elementReflectable);
1397
2
            }
1398
1
    );
1399
1400

1
    reflectable->resize(reflectable->size() + 1);
1401

2
    IReflectablePtr newCompound = reflectable->at(reflectable->size() - 1);
1402



1
    ASSERT_TRUE(newCompound);
1403
1404

1
    reflectable->setAt(AnyHolder<>(ReflectableObject{"test", ReflectableNested{0}}), 0);
1405




1
    ASSERT_EQ(0, reflectable->at(0)->find("reflectableNested.value")->getUInt32());
1406

1
    reflectable->append(AnyHolder<>(ReflectableObject{"test|", ReflectableNested{1}}));
1407





1
    ASSERT_EQ(1, reflectable->at(reflectable->size() - 1)->find("reflectableNested.value")->getUInt32());
1408
1409
1
    const size_t size = reflectable->size();
1410











2
    ASSERT_THROW(reflectable->setAt(AnyHolder<>(), size), CppRuntimeException); // out of range
1411
}
1412
1413


690
TEST_F(ReflectableTest, reflectableOwner)
1414
{
1415

2
    auto reflectable = ReflectableObject::typeInfo().createInstance();
1416
1417
    // must be as the first one to initialize object
1418








1
    ASSERT_NO_THROW(reflectable->initializeChildren());
1419
1420
2
    IReflectableConstPtr constReflectable = reflectable;
1421
1422
    // same as default initialized
1423
2
    ReflectableObject defaultReflectableObject;
1424
1
    defaultReflectableObject.initializeChildren();
1425




1
    ASSERT_EQ(defaultReflectableObject,
1426
            reflectable->getAnyValue().template get<std::reference_wrapper<ReflectableObject>>().get());
1427




1
    ASSERT_EQ(defaultReflectableObject,
1428
            constReflectable->getAnyValue().template get<std::reference_wrapper<ReflectableObject>>().get());
1429
1430



1
    ASSERT_FALSE(reflectable->isArray());
1431

1
    reflectable->setField("reflectableNested", AnyHolder<>(ReflectableNested{42}));
1432




1
    ASSERT_EQ(42, reflectable->getField("reflectableNested")->getField("value")->getUInt32());
1433




1
    ASSERT_EQ(42, constReflectable->getField("reflectableNested")->getField("value")->getUInt32());
1434










2
    ASSERT_THROW(reflectable->createField("nonexistent"), CppRuntimeException);
1435










2
    ASSERT_THROW(reflectable->getParameter("nonexistent"), CppRuntimeException);
1436










2
    ASSERT_THROW(constReflectable->getParameter("nonexistent"), CppRuntimeException);
1437










2
    ASSERT_THROW(reflectable->callFunction("nonexistent"), CppRuntimeException);
1438











2
    ASSERT_THROW(constReflectable->callFunction("nonexistent"), CppRuntimeException);
1439










2
    ASSERT_THROW(reflectable->getChoice(), CppRuntimeException);
1440









2
    ASSERT_THROW(constReflectable->getChoice(), CppRuntimeException);
1441



1
    ASSERT_FALSE(reflectable->find("nonexistent"));
1442



1
    ASSERT_FALSE(constReflectable->find("nonexistent"));
1443



1
    ASSERT_FALSE((*reflectable)["nonexistent"]);
1444




1
    ASSERT_FALSE((*constReflectable)["nonexistent"]);
1445
1446










2
    ASSERT_THROW(reflectable->size(), CppRuntimeException); // not an array
1447










2
    ASSERT_THROW(reflectable->resize(0), CppRuntimeException); // not an array
1448










2
    ASSERT_THROW(reflectable->at(0), CppRuntimeException); // not an array
1449










2
    ASSERT_THROW(constReflectable->at(0), CppRuntimeException); // not an array
1450










2
    ASSERT_THROW((*reflectable)[0], CppRuntimeException); // not an array
1451









2
    ASSERT_THROW((*constReflectable)[0], CppRuntimeException); // not an array
1452










2
    ASSERT_THROW(reflectable->setAt(AnyHolder<>(), 0), CppRuntimeException); // not an array
1453











2
    ASSERT_THROW(reflectable->append(AnyHolder<>()), CppRuntimeException); // not an array
1454
1455










2
    ASSERT_THROW(reflectable->getBool(), CppRuntimeException);
1456










2
    ASSERT_THROW(reflectable->getInt8(), CppRuntimeException);
1457










2
    ASSERT_THROW(reflectable->getInt16(), CppRuntimeException);
1458










2
    ASSERT_THROW(reflectable->getInt32(), CppRuntimeException);
1459










2
    ASSERT_THROW(reflectable->getInt64(), CppRuntimeException);
1460










2
    ASSERT_THROW(reflectable->getUInt8(), CppRuntimeException);
1461










2
    ASSERT_THROW(reflectable->getUInt16(), CppRuntimeException);
1462










2
    ASSERT_THROW(reflectable->getUInt32(), CppRuntimeException);
1463










2
    ASSERT_THROW(reflectable->getUInt64(), CppRuntimeException);
1464










2
    ASSERT_THROW(reflectable->getFloat(), CppRuntimeException);
1465










2
    ASSERT_THROW(reflectable->getDouble(), CppRuntimeException);
1466










2
    ASSERT_THROW(reflectable->getBytes(), CppRuntimeException);
1467










2
    ASSERT_THROW(reflectable->getStringView(), CppRuntimeException);
1468










2
    ASSERT_THROW(reflectable->getBitBuffer(), CppRuntimeException);
1469
1470










2
    ASSERT_THROW(reflectable->toInt(), CppRuntimeException);
1471










2
    ASSERT_THROW(reflectable->toUInt(), CppRuntimeException);
1472










2
    ASSERT_THROW(reflectable->toDouble(), CppRuntimeException);
1473









2
    ASSERT_THROW(reflectable->toString(), CppRuntimeException);
1474
1475




1
    ASSERT_EQ(reflectable->bitSizeOf(), reflectable->initializeOffsets());
1476
1477








1
    ASSERT_NO_THROW(reflectable->initializeChildren());
1478
1479
1
    const size_t bitSizeOfValue = reflectable->bitSizeOf();
1480

2
    BitBuffer bitBuffer(bitSizeOfValue);
1481
1
    BitStreamWriter writer(bitBuffer);
1482
1
    reflectable->write(writer);
1483



1
    ASSERT_EQ(bitSizeOfValue, writer.getBitPosition());
1484
}
1485
1486

2058
} // namespace zserio